home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / os2 / pccts.zip / ANTLR.C < prev    next >
C/C++ Source or Header  |  1992-12-08  |  19KB  |  912 lines
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Hank Dietz and Will Cohen: 1989-1992
  5.  * Purdue University Electrical Engineering
  6.  * ANTLR Version 1.06
  7.  */
  8. #include <stdio.h>
  9. #include "set.h"
  10. #include <ctype.h>
  11. #include "syn.h"
  12. #include "hash.h"
  13. #include "generic.h"
  14. #define zzcr_attr(attr,tok,t)
  15. #include "antlr.h"
  16. #include "tokens.h"
  17. #include "dlgdef.h"
  18. #include "mode.h"
  19. ANTLR_INFO
  20. #ifdef __STDC__
  21. static void chkToken(char *, char *, char *);
  22. #else
  23. static void chkToken();
  24. #endif
  25.  
  26. #ifdef __STDC__
  27. void
  28. grammar()
  29. #else
  30. grammar()
  31. #endif
  32. {
  33.     zzRULE;
  34.     zzBLOCK(zztasp1);
  35.     zzMake0;
  36.     {
  37.     Graph g;  
  38.     {
  39.         zzBLOCK(zztasp2);
  40.         zzMake0;
  41.         {
  42.         if ( (LA(1)==50) ) {
  43.             zzmatch(50); zzCONSUME;
  44.             zzmatch(Action);
  45.             HdrAction = calloc(strlen(LATEXT(1))+1, sizeof(char));
  46.             require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  47.             strcpy(HdrAction, LATEXT(1));
  48.              zzCONSUME;
  49.         }
  50.         zzEXIT(zztasp2);
  51.         }
  52.     }
  53.     {
  54.         zzBLOCK(zztasp2);
  55.         zzMake0;
  56.         {
  57.         char *a;  
  58.         while ( 1 ) {
  59.             if ( (LA(1)==Action) ) {
  60.                 zzmatch(Action);
  61.                 a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  62.                 require(a!=NULL, "rule grammar: cannot allocate action");
  63.                 strcpy(a, LATEXT(1));
  64.                 list_add(&BeforeActions, a);
  65.                  zzCONSUME;
  66.             }
  67.             else if ( (LA(1)==57) ) {
  68.                 laction();
  69.             }
  70.             else if ( (LA(1)==58) ) {
  71.                 aLexclass();
  72.             }
  73.             else if ( (LA(1)==63) ) {
  74.                 token();
  75.             }
  76.             else if ( (LA(1)==60) ) {
  77.                 error();
  78.             }
  79.             else break;
  80.             zzLOOP(zztasp2);
  81.         }
  82.         zzEXIT(zztasp2);
  83.         }
  84.     }
  85.     rule();
  86.     g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;  
  87.     {
  88.         zzBLOCK(zztasp2);
  89.         zzMake0;
  90.         {
  91.         while ( 1 ) {
  92.             if ( (LA(1)==NonTerminal) ) {
  93.                 rule();
  94.                 if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}  
  95.             }
  96.             else if ( (LA(1)==58) ) {
  97.                 aLexclass();
  98.             }
  99.             else if ( (LA(1)==63) ) {
  100.                 token();
  101.             }
  102.             else if ( (LA(1)==60) ) {
  103.                 error();
  104.             }
  105.             else break;
  106.             zzLOOP(zztasp2);
  107.         }
  108.         zzEXIT(zztasp2);
  109.         }
  110.     }
  111.     {
  112.         zzBLOCK(zztasp2);
  113.         zzMake0;
  114.         {
  115.         char *a;  
  116.         while ( 1 ) {
  117.             if ( (LA(1)==Action) ) {
  118.                 zzmatch(Action);
  119.                 a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  120.                 require(a!=NULL, "rule grammar: cannot allocate action");
  121.                 strcpy(a, LATEXT(1));
  122.                 list_add(&AfterActions, a);
  123.                  zzCONSUME;
  124.             }
  125.             else if ( (LA(1)==57) ) {
  126.                 laction();
  127.             }
  128.             else if ( (LA(1)==60) ) {
  129.                 error();
  130.             }
  131.             else break;
  132.             zzLOOP(zztasp2);
  133.         }
  134.         zzEXIT(zztasp2);
  135.         }
  136.     }
  137.     zzmatch(Eof); zzCONSUME;
  138.     zzEXIT(zztasp1);
  139.     return;
  140. fail:
  141.     zzEXIT(zztasp1);
  142.     CannotContinue=TRUE;  
  143.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  144.     zzresynch(setwd1, 0x1);
  145.     }
  146. }
  147.  
  148. #ifdef __STDC__
  149. void
  150. rule()
  151. #else
  152. rule()
  153. #endif
  154. {
  155.     zzRULE;
  156.     zzBLOCK(zztasp1);
  157.     zzMake0;
  158.     {
  159.     RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  160.     char *pdecl=NULL, *ret=NULL, *a;  
  161.     zzmatch(NonTerminal);
  162.     q=NULL;
  163.     if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  164.         warn(eMsg1("duplicate rule definition: '%s'",LATEXT(1)))
  165.         CannotContinue=TRUE;
  166.     }
  167.     else
  168.     {
  169.         q = (RuleEntry *)hash_add(Rname,
  170.         LATEXT(1),
  171.         (Entry *)newRuleEntry(LATEXT(1)));
  172.         CurRule = q->str;
  173.     }
  174.     CurRuleNode = q;
  175.     f = CurFile; l = zzline;
  176.     NumRules++;
  177.      zzCONSUME;
  178.     {
  179.         zzBLOCK(zztasp2);
  180.         zzMake0;
  181.         {
  182.         if ( (LA(1)==52) ) {
  183.             zzmatch(52);
  184.             if ( q!=NULL ) q->noAST = TRUE;  
  185.              zzCONSUME;
  186.         }
  187.         zzEXIT(zztasp2);
  188.         }
  189.     }
  190.     {
  191.         zzBLOCK(zztasp2);
  192.         zzMake0;
  193.         {
  194.         ;  
  195.         if ( (setwd1[LA(1)]&0x2) ) {
  196.             {
  197.                 zzBLOCK(zztasp3);
  198.                 zzMake0;
  199.                 {
  200.                 if ( (LA(1)==53) ) {
  201.                     zzmatch(53); zzCONSUME;
  202.                 }
  203.                 zzEXIT(zztasp3);
  204.                 }
  205.             }
  206.             zzmatch(PassAction);
  207.             pdecl = calloc(strlen(LATEXT(1))+1, sizeof(char));
  208.             require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  209.             strcpy(pdecl, LATEXT(1));
  210.             CurParmDef = pdecl;
  211.              zzCONSUME;
  212.         }
  213.         zzEXIT(zztasp2);
  214.         }
  215.     }
  216.     {
  217.         zzBLOCK(zztasp2);
  218.         zzMake0;
  219.         {
  220.         if ( (LA(1)==54) ) {
  221.             zzmatch(54); zzCONSUME;
  222.             zzmatch(PassAction);
  223.             ret = calloc(strlen(LATEXT(1))+1, sizeof(char));
  224.             require(ret!=NULL, "rule rule: cannot allocate ret type");
  225.             strcpy(ret, LATEXT(1));
  226.             CurRetDef = ret;
  227.              zzCONSUME;
  228.         }
  229.         zzEXIT(zztasp2);
  230.         }
  231.     }
  232.     {
  233.         zzBLOCK(zztasp2);
  234.         zzMake0;
  235.         {
  236.         if ( (LA(1)==QuotedTerm) ) {
  237.             zzmatch(QuotedTerm);
  238.             if ( q!=NULL ) q->egroup=strdup(LATEXT(1));  
  239.              zzCONSUME;
  240.         }
  241.         zzEXIT(zztasp2);
  242.         }
  243.     }
  244.     if ( GenEClasseForRules && q!=NULL ) {
  245.         e = newECnode;
  246.         require(e!=NULL, "cannot allocate error class node");
  247.         if ( q->egroup == NULL ) {a = q->str; a[0] = toupper(a[0]);}
  248.         else a = q->egroup;
  249.         if ( Tnum( a ) == 0 )
  250.         {
  251.             e->tok = addTname( a );
  252.             list_add(&eclasses, (char *)e);
  253.             if ( q->egroup == NULL ) a[0] = tolower(a[0]);
  254.             /* refers to itself */
  255.             list_add(&(e->elist), strdup(q->str));
  256.         }
  257.         else {
  258.             warn(eMsg1("default errclass for '%s' would conflict with token/errclass",a));
  259.             if ( q->egroup == NULL ) a[0] = tolower(a[0]);
  260.             free(e);
  261.         }
  262.     }
  263.     BlkLevel++;  
  264.     zzmatch(55); zzCONSUME;
  265.     block();
  266.     r = makeBlk(zzaArg(zztasp1,7));
  267.     ((Junction *)r.left)->jtype = RuleBlk;
  268.     if ( q!=NULL ) ((Junction *)r.left)->rname = q->str;
  269.     ((Junction *)r.left)->file = f;
  270.     ((Junction *)r.left)->line = l;
  271.     ((Junction *)r.left)->pdecl = pdecl;
  272.     ((Junction *)r.left)->ret = ret;
  273.     ((Junction *)r.left)->lock = makelocks();
  274.     ((Junction *)r.left)->pred_lock = makelocks();
  275.     p = newJunction();    /* add EndRule Node */
  276.     ((Junction *)r.right)->p1 = (Node *)p;
  277.     r.right = (Node *) p;
  278.     p->jtype = EndRule;
  279.     p->lock = makelocks();
  280.     p->pred_lock = makelocks();
  281.     ((Junction *)r.left)->end = p;
  282.     if ( q!=NULL ) q->rulenum = NumRules;
  283.     zzaArg(zztasp1,7) = r;
  284.     --BlkLevel;  
  285.     zzmatch(56); zzCONSUME;
  286.     {
  287.         zzBLOCK(zztasp2);
  288.         zzMake0;
  289.         {
  290.         if ( (LA(1)==Action) ) {
  291.             zzmatch(Action);
  292.             a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  293.             require(a!=NULL, "rule rule: cannot allocate error action");
  294.             strcpy(a, LATEXT(1));
  295.             ((Junction *)r.left)->erraction = a;
  296.              zzCONSUME;
  297.         }
  298.         zzEXIT(zztasp2);
  299.         }
  300.     }
  301.     if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);  
  302.     CurRuleNode = NULL;  
  303.     zzEXIT(zztasp1);
  304.     return;
  305. fail:
  306.     zzEXIT(zztasp1);
  307.     CannotContinue=TRUE;  
  308.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  309.     zzresynch(setwd1, 0x4);
  310.     }
  311. }
  312.  
  313. #ifdef __STDC__
  314. void
  315. laction()
  316. #else
  317. laction()
  318. #endif
  319. {
  320.     zzRULE;
  321.     zzBLOCK(zztasp1);
  322.     zzMake0;
  323.     {
  324.     char *a;  
  325.     zzmatch(57); zzCONSUME;
  326.     zzmatch(Action);
  327.     a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  328.     require(a!=NULL, "rule laction: cannot allocate action");
  329.     strcpy(a, LATEXT(1));
  330.     list_add(&LexActions, a);
  331.      zzCONSUME;
  332.     zzEXIT(zztasp1);
  333.     return;
  334. fail:
  335.     zzEXIT(zztasp1);
  336.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  337.     zzresynch(setwd1, 0x8);
  338.     }
  339. }
  340.  
  341. #ifdef __STDC__
  342. void
  343. aLexclass()
  344. #else
  345. aLexclass()
  346. #endif
  347. {
  348.     zzRULE;
  349.     zzBLOCK(zztasp1);
  350.     zzMake0;
  351.     {
  352.     zzmatch(58); zzCONSUME;
  353.     zzmatch(TokenTerm);
  354.     lexclass(strdup(LATEXT(1)));  
  355.      zzCONSUME;
  356.     zzEXIT(zztasp1);
  357.     return;
  358. fail:
  359.     zzEXIT(zztasp1);
  360.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  361.     zzresynch(setwd1, 0x10);
  362.     }
  363. }
  364.  
  365. #ifdef __STDC__
  366. void
  367. error()
  368. #else
  369. error()
  370. #endif
  371. {
  372.     zzRULE;
  373.     zzBLOCK(zztasp1);
  374.     zzMake0;
  375.     {
  376.     char *t=NULL; ECnode *e; int go=1; TermEntry *p;  
  377.     zzmatch(60); zzCONSUME;
  378.     {
  379.         zzBLOCK(zztasp2);
  380.         zzMake0;
  381.         {
  382.         ;  
  383.         if ( (LA(1)==TokenTerm) ) {
  384.             zzmatch(TokenTerm);
  385.             t=strdup(LATEXT(1));  
  386.              zzCONSUME;
  387.         }
  388.         else if ( (LA(1)==QuotedTerm) ) {
  389.             zzmatch(QuotedTerm);
  390.             t=strdup(LATEXT(1));  
  391.              zzCONSUME;
  392.         }
  393.         else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  394.         zzEXIT(zztasp2);
  395.         }
  396.     }
  397.     e = newECnode;
  398.     require(e!=NULL, "cannot allocate error class node");
  399.     e->lexclass = CurrentLexClass;
  400.     if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  401.     {
  402.         if ( hash_get(Texpr, t) != NULL )
  403.         warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  404.         e->tok = addTname( t );
  405.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  406.         "hash table mechanism is broken");
  407.         p->errclassname = 1;    /* entry is errclass name, not token */
  408.         list_add(&eclasses, (char *)e);
  409.     }
  410.     else
  411.     {
  412.     warn(eMsg1("redefinition of errclass or conflict w/token '%s'; ignored",t));
  413.     free( e );
  414.     go=0;
  415. }
  416.     zzmatch(61); zzCONSUME;
  417.     {
  418.         zzBLOCK(zztasp2);
  419.         zzMake0;
  420.         {
  421.         if ( (LA(1)==NonTerminal) ) {
  422.             zzmatch(NonTerminal);
  423.             if ( go ) t=strdup(LATEXT(1));  
  424.              zzCONSUME;
  425.         }
  426.         else if ( (LA(1)==TokenTerm) ) {
  427.             zzmatch(TokenTerm);
  428.             if ( go ) t=strdup(LATEXT(1));  
  429.              zzCONSUME;
  430.         }
  431.         else if ( (LA(1)==QuotedTerm) ) {
  432.             zzmatch(QuotedTerm);
  433.             if ( go ) t=strdup(LATEXT(1));  
  434.              zzCONSUME;
  435.         }
  436.         else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  437.         zzEXIT(zztasp2);
  438.         }
  439.     }
  440.     if ( go ) list_add(&(e->elist), t);  
  441.     {
  442.         zzBLOCK(zztasp2);
  443.         zzMake0;
  444.         {
  445.         while ( (setwd1[LA(1)]&0x20) ) {
  446.             {
  447.                 zzBLOCK(zztasp3);
  448.                 zzMake0;
  449.                 {
  450.                 if ( (LA(1)==NonTerminal) ) {
  451.                     zzmatch(NonTerminal);
  452.                     if ( go ) t=strdup(LATEXT(1));  
  453.                      zzCONSUME;
  454.                 }
  455.                 else if ( (LA(1)==TokenTerm) ) {
  456.                     zzmatch(TokenTerm);
  457.                     if ( go ) t=strdup(LATEXT(1));  
  458.                      zzCONSUME;
  459.                 }
  460.                 else if ( (LA(1)==QuotedTerm) ) {
  461.                     zzmatch(QuotedTerm);
  462.                     if ( go ) t=strdup(LATEXT(1));  
  463.                      zzCONSUME;
  464.                 }
  465.                 else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  466.                 zzEXIT(zztasp3);
  467.                 }
  468.             }
  469.             if ( go ) list_add(&(e->elist), t);  
  470.             zzLOOP(zztasp2);
  471.         }
  472.         zzEXIT(zztasp2);
  473.         }
  474.     }
  475.     zzmatch(62); zzCONSUME;
  476.     zzEXIT(zztasp1);
  477.     return;
  478. fail:
  479.     zzEXIT(zztasp1);
  480.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  481.     zzresynch(setwd1, 0x40);
  482.     }
  483. }
  484.  
  485. #ifdef __STDC__
  486. void
  487. token()
  488. #else
  489. token()
  490. #endif
  491. {
  492.     zzRULE;
  493.     zzBLOCK(zztasp1);
  494.     zzMake0;
  495.     {
  496.     char *t=NULL, *e=NULL, *a=NULL;  
  497.     zzmatch(63); zzCONSUME;
  498.     {
  499.         zzBLOCK(zztasp2);
  500.         zzMake0;
  501.         {
  502.         if ( (LA(1)==TokenTerm) ) {
  503.             zzmatch(TokenTerm);
  504.             t=strdup(LATEXT(1));  
  505.              zzCONSUME;
  506.         }
  507.         zzEXIT(zztasp2);
  508.         }
  509.     }
  510.     {
  511.         zzBLOCK(zztasp2);
  512.         zzMake0;
  513.         {
  514.         if ( (LA(1)==QuotedTerm) ) {
  515.             zzmatch(QuotedTerm);
  516.             e=strdup(LATEXT(1));  
  517.              zzCONSUME;
  518.         }
  519.         zzEXIT(zztasp2);
  520.         }
  521.     }
  522.     {
  523.         zzBLOCK(zztasp2);
  524.         zzMake0;
  525.         {
  526.         if ( (LA(1)==Action) ) {
  527.             zzmatch(Action);
  528.             a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  529.             require(a!=NULL, "rule token: cannot allocate action");
  530.             strcpy(a, LATEXT(1));
  531.              zzCONSUME;
  532.         }
  533.         zzEXIT(zztasp2);
  534.         }
  535.     }
  536.     chkToken(t, e, a);  
  537.     zzEXIT(zztasp1);
  538.     return;
  539. fail:
  540.     zzEXIT(zztasp1);
  541.     CannotContinue=TRUE;  
  542.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  543.     zzresynch(setwd1, 0x80);
  544.     }
  545. }
  546.  
  547. #ifdef __STDC__
  548. void
  549. block()
  550. #else
  551. block()
  552. #endif
  553. {
  554.     zzRULE;
  555.     zzBLOCK(zztasp1);
  556.     zzMake0;
  557.     {
  558.     Graph g, b;  
  559.     alt();
  560.     b = g = zzaArg(zztasp1,1);  
  561.     if ( ((Junction *)g.left)->p1->ntype == nAction )
  562.     {
  563.         if ( !((ActionNode *)(((Junction *)g.left)->p1))->is_predicate )
  564.         {
  565.             ((ActionNode *)(((Junction *)g.left)->p1))->init_action = TRUE;
  566.         }
  567.     }
  568.     {
  569.         zzBLOCK(zztasp2);
  570.         zzMake0;
  571.         {
  572.         while ( (LA(1)==64) ) {
  573.             zzmatch(64); zzCONSUME;
  574.             alt();
  575.             g = Or(g, zzaArg(zztasp2,2));  
  576.             zzLOOP(zztasp2);
  577.         }
  578.         zzEXIT(zztasp2);
  579.         }
  580.     }
  581.     zzaArg(zztasp1,0) = b;  
  582.     zzEXIT(zztasp1);
  583.     return;
  584. fail:
  585.     zzEXIT(zztasp1);
  586.     CannotContinue=TRUE;  
  587.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  588.     zzresynch(setwd1, 0x100);
  589.     }
  590. }
  591.  
  592. #ifdef __STDC__
  593. void
  594. alt()
  595. #else
  596. alt()
  597. #endif
  598. {
  599.     zzRULE;
  600.     zzBLOCK(zztasp1);
  601.     zzMake0;
  602.     {
  603.     int n=0; Graph g; g.left=g.right=NULL;  
  604.     {
  605.         zzBLOCK(zztasp2);
  606.         zzMake0;
  607.         {
  608.         while ( (setwd1[LA(1)]&0x200) ) {
  609.             element();
  610.             n++; g = Cat(g, zzaArg(zztasp2,1));  
  611.             zzLOOP(zztasp2);
  612.         }
  613.         zzEXIT(zztasp2);
  614.         }
  615.     }
  616.     if ( n == 0 ) g = emptyAlt();
  617.     zzaArg(zztasp1,0) = g;
  618.     zzEXIT(zztasp1);
  619.     return;
  620. fail:
  621.     zzEXIT(zztasp1);
  622.     CannotContinue=TRUE;  
  623.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  624.     zzresynch(setwd1, 0x400);
  625.     }
  626. }
  627.  
  628. #ifdef __STDC__
  629. void
  630. element()
  631. #else
  632. element()
  633. #endif
  634. {
  635.     zzRULE;
  636.     zzBLOCK(zztasp1);
  637.     zzMake0;
  638.     {
  639.     TokNode *p; RuleRefNode *q;  
  640.     if ( (LA(1)==TokenTerm) ) {
  641.         zzmatch(TokenTerm);
  642.         zzaArg(zztasp1,0) = buildToken(LATEXT(1));  
  643.          zzCONSUME;
  644.         {
  645.             zzBLOCK(zztasp2);
  646.             zzMake0;
  647.             {
  648.             p = (TokNode *) ((Junction *)zzaRet.left)->p1;  
  649.             if ( (LA(1)==65) ) {
  650.                 zzmatch(65);
  651.                 p->astnode=ASTroot;  
  652.                  zzCONSUME;
  653.             }
  654.             else if ( (setwd1[LA(1)]&0x800) ) {
  655.                 p->astnode=ASTchild;  
  656.             }
  657.             else if ( (LA(1)==52) ) {
  658.                 zzmatch(52);
  659.                 p->astnode=ASTexclude;  
  660.                  zzCONSUME;
  661.             }
  662.             else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  663.             zzEXIT(zztasp2);
  664.             }
  665.         }
  666.     }
  667.     else if ( (LA(1)==QuotedTerm) ) {
  668.         zzmatch(QuotedTerm);
  669.         zzaArg(zztasp1,0) = buildToken(LATEXT(1));  
  670.          zzCONSUME;
  671.         {
  672.             zzBLOCK(zztasp2);
  673.             zzMake0;
  674.             {
  675.             p = (TokNode *) ((Junction *)zzaRet.left)->p1;  
  676.             if ( (LA(1)==65) ) {
  677.                 zzmatch(65);
  678.                 p->astnode=ASTroot;  
  679.                  zzCONSUME;
  680.             }
  681.             else if ( (setwd1[LA(1)]&0x1000) ) {
  682.                 p->astnode=ASTchild;  
  683.             }
  684.             else if ( (LA(1)==52) ) {
  685.                 zzmatch(52);
  686.                 p->astnode=ASTexclude;  
  687.                  zzCONSUME;
  688.             }
  689.             else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  690.             zzEXIT(zztasp2);
  691.             }
  692.         }
  693.     }
  694.     else if ( (LA(1)==NonTerminal) ) {
  695.         zzmatch(NonTerminal);
  696.         zzaArg(zztasp1,0) = buildRuleRef(LATEXT(1));  
  697.          zzCONSUME;
  698.         {
  699.             zzBLOCK(zztasp2);
  700.             zzMake0;
  701.             {
  702.             if ( (LA(1)==52) ) {
  703.                 zzmatch(52);
  704.                 q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  705.                 q->astnode=ASTexclude;  
  706.                  zzCONSUME;
  707.             }
  708.             zzEXIT(zztasp2);
  709.             }
  710.         }
  711.         {
  712.             zzBLOCK(zztasp2);
  713.             zzMake0;
  714.             {
  715.             if ( (setwd1[LA(1)]&0x2000) ) {
  716.                 {
  717.                     zzBLOCK(zztasp3);
  718.                     zzMake0;
  719.                     {
  720.                     if ( (LA(1)==53) ) {
  721.                         zzmatch(53); zzCONSUME;
  722.                     }
  723.                     zzEXIT(zztasp3);
  724.                     }
  725.                 }
  726.                 zzmatch(PassAction);
  727.                 addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  728.                  zzCONSUME;
  729.             }
  730.             zzEXIT(zztasp2);
  731.             }
  732.         }
  733.         {
  734.             zzBLOCK(zztasp2);
  735.             zzMake0;
  736.             {
  737.             char *a; RuleRefNode *rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  738.             if ( (LA(1)==54) ) {
  739.                 zzmatch(54); zzCONSUME;
  740.                 zzmatch(PassAction);
  741.                 a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  742.                 require(a!=NULL, "rule element: cannot allocate assignment");
  743.                 strcpy(a, LATEXT(1));
  744.                 rr->assign = a;
  745.                  zzCONSUME;
  746.             }
  747.             zzEXIT(zztasp2);
  748.             }
  749.         }
  750.     }
  751.     else if ( (LA(1)==Action) ) {
  752.         zzmatch(Action);
  753.         zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);  
  754.          zzCONSUME;
  755.     }
  756.     else if ( (LA(1)==Pred) ) {
  757.         zzmatch(Pred);
  758.         zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);  
  759.          zzCONSUME;
  760.         {
  761.             zzBLOCK(zztasp2);
  762.             zzMake0;
  763.             {
  764.             char *a; ActionNode *act = (ActionNode *) ((Junction *)zzaRet.left)->p1;  
  765.             if ( (LA(1)==PassAction) ) {
  766.                 zzmatch(PassAction);
  767.                 a = calloc(strlen(LATEXT(1))+1, sizeof(char));
  768.                 require(a!=NULL, "rule element: cannot allocate predicate fail action");
  769.                 strcpy(a, LATEXT(1));
  770.                 act->pred_fail = a;
  771.                  zzCONSUME;
  772.             }
  773.             zzEXIT(zztasp2);
  774.             }
  775.         }
  776.     }
  777.     else if ( (LA(1)==66) ) {
  778.         BlkLevel++;  
  779.         zzmatch(66); zzCONSUME;
  780.         block();
  781.         zzaArg(zztasp1,0) = zzaArg(zztasp1,2); --BlkLevel;  
  782.         zzmatch(67); zzCONSUME;
  783.         {
  784.             zzBLOCK(zztasp2);
  785.             zzMake0;
  786.             {
  787.             if ( (LA(1)==68) ) {
  788.                 zzmatch(68);
  789.                 zzaRet = makeLoop(zzaRet);  
  790.                  zzCONSUME;
  791.             }
  792.             else if ( (LA(1)==69) ) {
  793.                 zzmatch(69);
  794.                 zzaRet = makePlus(zzaRet);  
  795.                  zzCONSUME;
  796.             }
  797.             else if ( (setwd1[LA(1)]&0x4000) ) {
  798.                 zzaRet = makeBlk(zzaRet);  
  799.             }
  800.             else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  801.             zzEXIT(zztasp2);
  802.             }
  803.         }
  804.         {
  805.             zzBLOCK(zztasp2);
  806.             zzMake0;
  807.             {
  808.             if ( (LA(1)==PassAction) ) {
  809.                 zzmatch(PassAction);
  810.                 addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  811.                  zzCONSUME;
  812.             }
  813.             zzEXIT(zztasp2);
  814.             }
  815.         }
  816.     }
  817.     else if ( (LA(1)==61) ) {
  818.         BlkLevel++;  
  819.         zzmatch(61); zzCONSUME;
  820.         block();
  821.         zzaArg(zztasp1,0) = makeOpt(zzaArg(zztasp1,2)); --BlkLevel;  
  822.         zzmatch(62); zzCONSUME;
  823.         {
  824.             zzBLOCK(zztasp2);
  825.             zzMake0;
  826.             {
  827.             if ( (LA(1)==PassAction) ) {
  828.                 zzmatch(PassAction);
  829.                 addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  830.                  zzCONSUME;
  831.             }
  832.             zzEXIT(zztasp2);
  833.             }
  834.         }
  835.     }
  836.     else if ( (LA(1)==55) ) {
  837.         zzmatch(55);
  838.         warn(eMsg1("missing ';' on rule %s", CurRule));
  839.         CannotContinue=TRUE;  
  840.          zzCONSUME;
  841.     }
  842.     else if ( (LA(1)==68) ) {
  843.         zzmatch(68);
  844.         warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;  
  845.          zzCONSUME;
  846.     }
  847.     else if ( (LA(1)==69) ) {
  848.         zzmatch(69);
  849.         warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;  
  850.          zzCONSUME;
  851.     }
  852.     else if ( (LA(1)==54) ) {
  853.         zzmatch(54);
  854.         warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;  
  855.          zzCONSUME;
  856.     }
  857.     else if ( (LA(1)==PassAction) ) {
  858.         zzmatch(PassAction);
  859.         warn("[...] out of context 'rule > [...]'");
  860.         CannotContinue=TRUE;  
  861.          zzCONSUME;
  862.     }
  863.     else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  864.     zzEXIT(zztasp1);
  865.     return;
  866. fail:
  867.     zzEXIT(zztasp1);
  868.     CannotContinue=TRUE;  
  869.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  870.     zzresynch(setwd1, 0x8000);
  871.     }
  872. }
  873. /* semantics of #token */
  874. static void
  875. chkToken(t,e,a)
  876. char *t, *e, *a;
  877. {
  878.     if ( t==NULL && e==NULL ) {            /* none found */
  879.         warn("#token requires at least token name or rexpr");
  880.     }
  881.     else if ( t!=NULL && e!=NULL ) {    /* both found */
  882.         Tlink(t, e);
  883.         if ( a!=NULL ) {
  884.             if ( hasAction(e) ) {
  885.                 warn(eMsg1("redefinition of action for %s; ignored",e));
  886.             }
  887.             else setHasAction(e, a);
  888.         }
  889.     }
  890.     else if ( t!=NULL ) {                /* only one found */
  891.         if ( Tnum( t ) == 0 ) addTname( t );
  892.         else {
  893.             warn(eMsg1("redefinition of token %s; ignored",t));
  894.         }
  895.         if ( a!=NULL ) {
  896.             warn(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  897.         }
  898.     }
  899.     else if ( e!=NULL ) {
  900.         if ( Tnum( e ) == 0 ) addTexpr( e );
  901.         else {
  902.             if ( hasAction(e) ) {
  903.                 warn(eMsg1("redefinition of action for %s; ignored",e));
  904.             }
  905.             else if ( a==NULL ) {
  906.                 warn(eMsg1("redefinition of expr %s; ignored",e));
  907.             }
  908.         }
  909.         if ( a!=NULL ) setHasAction(e, a);
  910.     }
  911. }
  912.